package com.sky.controller.admin;

import com.sky.dto.DishDTO;
import com.sky.dto.DishPageQueryDTO;
import com.sky.entity.Dish;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.DishService;
import com.sky.vo.DishVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * @author bairimengchang
 * @version 1.0
 * @project sky-take-out
 * @description 菜品控制器
 * @date 2024/08/08 11:24:15
 */
@RestController
@RequestMapping("/admin/dish")
@Slf4j
@Api(tags = "菜品相关接口")
public class DishController {

    @Autowired
    private DishService dishService;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 新增菜品
     * @param dishDTO 菜品数据传输数据模型
     * @return 新增菜品成功或失败信息结果对象
     */
    @ApiOperation("新增菜品")
    @PostMapping
    public Result<String> addDish(@RequestBody DishDTO dishDTO) {
        log.info("新增菜品");
        log.info("前端传来的新增菜品信息:{}", dishDTO);
        boolean b = dishService.addDish(dishDTO);
        if (b) {
            log.info("新增菜品成功，删除redis缓存");
            //清理缓存数据，直接删除这个菜品分类下的所有菜品
            String key = "dish_" + dishDTO.getCategoryId();
            cleanCache(key);
            return Result.success("新增菜品成功！");
        }
        return Result.error("新增菜品失败，后端控制器报错！");
    }

    /**
     * 菜品分页查询
     * @param dishPageQueryDTO 菜品分页查询时传递的数据模型
     * @return 分页查询结果结果对象
     */
    @ApiOperation("菜品分页查询")
    @GetMapping("/page")
    public Result<PageResult> getDishPage(DishPageQueryDTO dishPageQueryDTO) {
        log.info("菜品分页查询");
        log.info("前端传来的菜品查询条件:{}", dishPageQueryDTO);
        PageResult pageResult = dishService.getDishPage(dishPageQueryDTO);
        return Result.success(pageResult);
    }


    /**
     * 修改菜品起售、停售状态
     * @param status 菜品售卖状态
     * @param id 要修改售卖状态的菜品id
     * @return 修改成功或失败信息结果对象
     */
    @ApiOperation("菜品起售、停售")
    @PostMapping("/status/{status}")
    public Result<String> changeDishStatus(@PathVariable("status") Integer status, @RequestParam("id") Long id) {
        // TODO 按标准来，前后端交互都应该封装一个VO对象
        //这里用@RequestParam，是因为前端给的是http://localhost:8888/api/dish/status/0?id=69
        log.info("菜品起售、停售");
        boolean b = dishService.changeDishStatus(status, id);
        if (b) {
            log.info("菜品起售、停售成功，删除redis缓存");
            //清理缓存数据，直接删除所有菜品
            cleanCache("dish_*");
            return Result.success("修改菜品售卖状态成功！");
        }
        return Result.error("修改菜品售卖状态失败，后端控制器报错！");
    }

    /**
     * 根据id查询菜品
     * @param id 要查询的菜品的id
     * @return 符合查询条件的菜品详情视图信息结果对象
     */
    @ApiOperation("根据id查询菜品")
    @GetMapping("/{id}")
    public Result<DishVO> getDishById(@PathVariable("id") Long id) {
        log.info("根据id查询菜品");
        DishVO dishVO = dishService.getDishById(id);
        log.info("菜品信息:{}", dishVO);
        return Result.success(dishVO);
    }

    /**
     * 修改菜品
     * @param dishDTO 菜品数据传输数据模型
     * @return 修改成功或失败信息结果对象
     */
    @ApiOperation("修改菜品")
    @PutMapping
    public Result<String> changeDish(@RequestBody DishDTO dishDTO) {
        log.info("修改菜品");
        boolean b = dishService.changeDish(dishDTO);
        if (b) {
            log.info("修改菜品成功，删除redis缓存");
            //清理缓存数据，直接删除所有菜品
            cleanCache("dish_*");
            return Result.success("修改菜品成功！");
        }
        return Result.error("修改菜品失败，后端控制器报错！");
    }

    /**
     * 根据分类id查询菜品
     * @param categoryId 分类id
     * @return 该分类id下的所有菜品的结果对象
     */
    @ApiOperation("根据分类id查询菜品")
    @GetMapping("/list")
    public Result<List<Dish>> getDishList(@RequestParam("categoryId") Long categoryId) {
        log.info("根据分类id查询菜品");
        List<Dish> dishList = dishService.getByCategoryId(categoryId);
        return Result.success(dishList);
    }

    /**
     * 批量删除菜品
     * @param ids 菜品id，之间用逗号分隔
     * @return 删除成功或失败信息结果对象
     */
    @ApiOperation("批量删除菜品")
    @DeleteMapping
    public Result<String> removeBatchDish(@RequestParam("ids") ArrayList<Long> ids) {
        //上面那样写就能直接把参数当作集合使用
        log.info("批量删除菜品");
        log.info("前端传来的ids:{}", ids);
        boolean b = dishService.removeBatchDish(ids);
        if (b) {
            log.info("批量删除菜品菜品成功，删除redis缓存");
            //清理缓存数据，直接删除所有菜品
            cleanCache("dish_*");
            return Result.success("批量删除菜品成功！");
        }
        return Result.error("批量删除菜品失败，后端控制器报错！");
    }


    /**
     * 清理缓存数据
     * @param pattern 要删除的键值，redis可以模糊删除
     */
    private void cleanCache(String pattern){
        //调用keys方法来查找所有匹配给定模式的键
        Set<String> keys = redisTemplate.keys(pattern);
        if (keys != null && !keys.isEmpty()) {
            //删除，传一个键的集合
            redisTemplate.delete(keys);
        }
    }

}
